export default {
    isPresent,
    isHex,
    isRgb,
    isRgba,
    isHsl,
    colorType,
    arrToRgb,
    arrToHex,
    arrToHsl,
    arrToColor,
    hexToArray,
    rgbaToArray,
    hslToArray,
    rgbToHsl,
    randomColor,
    reserveColor,
    transColorType,
    parseColorToArray
}

// 判断是否为百分数
function isPresent(str){
    let rex = /^[\d.]*%$/
    return rex.test(str)
}

// 判断是否为hex格式 有范围限制
function isHex(colorStr) {
    return !!colorStr.match(/^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/);
}

// 判断是否为rgb格式 有范围限制 可以是百分数
function isRgb(colorStr) {
    const rgbRegex = /^rgb\s*\(\s*((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)|(100%|([1-9]?\d|0)(\.\d+)?%))\s*,\s*((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)|(100%|([1-9]?\d|0)(\.\d+)?%))\s*,\s*((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)|(100%|([1-9]?\d|0)(\.\d+)?%))\s*\)\s*$/i;
    return rgbRegex.test(colorStr)
}

// 判断是否为rgba格式 有范围限制 可以是百分数
function isRgba(colorStr) {
    const rgbaRegex = /^rgba\s*\(\s*((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)|(100%|([1-9]?\d|0)(\.\d+)?%))\s*,\s*((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)|(100%|([1-9]?\d|0)(\.\d+)?%))\s*,\s*((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)|(100%|([1-9]?\d|0)(\.\d+)?%))\s*,\s*((0(\.\d+)?|1(\.0+)?|\.\d+|(100%|([1-9]?\d|0)(\.\d+)?%)))\s*\)\s*$/i;
    return rgbaRegex.test(colorStr)
}

// 判断是否为hsl/hsla格式 有范围限制 可以是百分数
function isHsl(colorStr) {
    const hslRegex = /^(hsla?)\s*\(\s*((?:360(?:\.0+)?|3[0-5]\d(?:\.\d+)?|\d{1,2}(?:\.\d+)?|[1-2]\d{2}(?:\.\d+)?))\s*,\s*((?:\d{1,3}(?:\.\d+)?%|0(?:\.\d+)?|1(?:\.0+)?))\s*,\s*((?:\d{1,3}(?:\.\d+)?%|0(?:\.\d+)?|1(?:\.0+)?))\s*(?:,\s*(0|1|0?\.\d+|1\.0+)\s*)?\)\s*$/i;
    let result = colorStr.match(hslRegex)
    if(result){
        return result[1]
    }
    return null
}

// 判断color格式类型
function colorType(color) {
    if(isHex(color)) return "hex";
    if(isRgb(color)) return "rgb";
    if(isRgba(color)) return "rgba";
    return isHsl(color)
}

// hex格式转化为arr数组 返回[r,g,b,a]格式数据，a默认为1并且限制两位
function hexToArray(colorStr) {
    const hexMatch = colorStr.match(/^#([0-9a-f]{3,8})$/i);
    if (hexMatch) {
        let hex = hexMatch[1];  //获取匹配分组 括号里面的
        // 扩展缩写格式（如 #RGB → RRGGBB）
        if (hex.length <= 4) {
            hex = hex.split('').map(c => c + c).join('');
        }
        // 提取 RGB 和 Alpha 通道
        let r = parseInt(hex.substring(0, 2), 16);
        let g = parseInt(hex.substring(2, 4), 16);
        let b = parseInt(hex.substring(4, 6), 16);
        let a = hex.length >= 8 ?
            (parseInt(hex.substring(6, 8), 16) / 255).toFixed(2)-0 : 1;
        return [r, g, b, a];
    }
}

//rgb、rgba转数组 a有默认为1
function rgbaToArray(colorStr) {
    const rgbMatch = colorStr.match(/rgba?\s*\(\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*,\s*([\d.]+%?)\s*(?:,\s*([\d.]+)\s*)?\s*\)\s*$/i);
    if (rgbMatch) {
        const parseValue = (val) =>
            val.endsWith('%') ? Math.round(parseFloat(val) * 2.55) : parseInt(val, 10);
        let r = parseValue(rgbMatch[1]);
        let g = parseValue(rgbMatch[2]);
        let b = parseValue(rgbMatch[3]);
        let a = rgbMatch[4] ? parseFloat(rgbMatch[4]) : 1;
        return [r, g, b, a];
    }

}

// hsl/hsla转为数组 a有默认为1
function hslToArray(colorStr) {
    const hslMatch = colorStr.match(/hsla?\s*\(\s*([\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*(?:,\s*([\d.]+)\s*)?\)\s*$/i);
    if (hslMatch) {
        const h = (parseFloat(hslMatch[1]) % 360) / 360;
        const s = parseFloat(hslMatch[2]) / 100;
        const l = parseFloat(hslMatch[3]) / 100;
        let a = hslMatch[4] ? parseFloat(hslMatch[4]) : 1;

        // HSL → RGB 转换算法（参考 W3C 标准）
        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        const p = 2 * l - q;
        const hue2rgb = (t) => {
            if (t < 0) t += 1;
            if (t > 1) t -= 1;
            if (t < 1/6) return p + (q - p) * 6 * t;
            if (t < 1/2) return q;
            if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
            return p;
        };

        let r = Math.round(hue2rgb(h + 1/3) * 255);
        let g = Math.round(hue2rgb(h) * 255);
        let b = Math.round(hue2rgb(h - 1/3) * 255);
        return [r, g, b, a];
    }
}

// color转数组 转的都是数字类型，透明通道都是0-1 a有默认为1
function parseColorToArray(colorStr){
    return  hexToArray(colorStr) || rgbaToArray(colorStr) || hslToArray(colorStr)
}

// arr转hex  有preserveAlpha就是8位，否则就是6位的
function arrToHex(arr, preserveAlpha = true) {
    const [r, g, b] = arr;
    const a = arr.length >= 4 ? arr[3] : 1; // 默认透明度为1
    const toHex = (value) =>
        Math.min(255, Math.max(0, value))  // 确保值在0-255之间
            .toString(16)
            .padStart(2, '0').toUpperCase();

    let hex = `#${toHex(r)}${toHex(g)}${toHex(b)}`;
    if (preserveAlpha) {
        const alphaHex = Math.round(a * 255).toString(16).padStart(2, '0').toUpperCase();
        hex += alphaHex; // 添加透明通道
    }
    return hex;
}

// arr转rgba
function arrToRgb(arr, preserveAlpha = true) {
    const [r, g, b] = arr;
    const a = arr.length >= 4 ? arr[3] : 1;
    if (preserveAlpha && arr.length === 4) {
        return `rgba(${r}, ${g}, ${b}, ${a})`; // 包含透明通道
    } else {
        return `rgb(${r}, ${g}, ${b})`; // 不包含透明通道
    }
}

// [r,g,b]转hsl 下面函数要用
function rgbToHsl(r, g, b) {
    r /= 255, g /= 255, b /= 255;
    const max = Math.max(r, g, b), min = Math.min(r, g, b);
    let h, s, l = (max + min) / 2;

    if (max === min) {
        h = s = 0; // 无色调的灰色
    } else {
        const d = max - min;
        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
        switch (max) {
            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
            case g: h = (b - r) / d + 2; break;
            case b: h = (r - g) / d + 4; break;
        }
        h /= 6;
    }
    return {
        h: Math.round(h * 360),  // 色相转为0-360度
        s: Math.round(s * 100),  // 饱和度转为百分比
        l: Math.round(l * 100)   // 亮度转为百分比
    };
}

// arr转数组 有preserveAlpha就是有a,没有就是hsl
function arrToHsl(arr, preserveAlpha = true) {
    const [r, g, b] = arr;
    const a = arr.length >= 4 ? arr[3] : 1;
    const { h, s, l } = rgbToHsl(r, g, b);

    if (preserveAlpha && arr.length === 4) {
        return `hsla(${h}, ${s}%, ${l}%, ${a})`;
    } else {
        return `hsl(${h}, ${s}%, ${l}%)`;
    }
}

//arrtocolor
function arrToColor(arr,type) {
    switch (type) {
        case "hsl" : return arrToHsl(arr,false)
        case "hsla": return arrToHsl(arr)
        case "rgb" : return arrToRgb(arr,false)
        case "rgba" : return arrToRgb(arr)
        case "hex" : return arrToHex(arr,false)
        case "hexa" : return arrToHex(arr)

    }
    return new Error("not color type:" + type)
}

// 转化颜色类型 传入颜色字符串，写上要转化的字符（默认hex） 是否开启颜色通道（默认开启 如果没有就是1）
function transColorType(color,type="hex",preserveAlpha = true){
    var colortype = colorType(color)
    if(colortype === type) return color
    else {
        let rgbaArr = parseColorToArray(color)
        if(rgbaArr){
            if(type === "hex"){
                return arrToHex(rgbaArr, preserveAlpha)
            }else if(type==="rgb"){
                return arrToRgb(rgbaArr, false)
            }else if(type ==="rgba"){
                return arrToRgb(rgbaArr)
            }else if(type ==="hsl"){
                return arrToHsl(rgbaArr, false)
            }else if(type === "hsla"){
                return arrToHsl(rgbaArr,preserveAlpha)
            }
        }
        return "Not color type"
    }
}

// 随机颜色
function randomColor(type,preserveAlpha) {
    let arr = [0,1,2,3,4,5,6,7,8,9,"a","b","c","d","e","f"]
    let strlen = preserveAlpha?8:6
    let str = "#"
    for(var i=0;i<strlen;i++){
        str +=  arr[Math.floor(Math.random()*arr.length)]
    }
    if(type&&type!=="hex"){
        return transColorType(str,type,preserveAlpha)
    }
    return str
}

// 反转色
function reserveColor(color,alpha=false) {
    let colortype = colorType(color)
    if(colortype){
        let arr = parseColorToArray(color)  //默认透明为1
        let reservecolor = []
        for(var i=0;i<3;i++){
            reservecolor[i] = 255 - arr[i]
        }
        if(alpha)
            reservecolor.push(arr[3])
        return arrToColor(reservecolor,colortype)
    }
}

// 变亮
// 变暗
// 滤色
// 灰度
// 正片叠底
// 相加  算平均
// 相减
// max
// min
